home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / GramYacc.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  24KB  |  979 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_StringMem
  20. #include "StringMem.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Texts
  28. #include "Texts.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sets
  32. #include "Sets.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeC2
  36. #include "TreeC2.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Strings
  44. #include "Strings.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_GramYacc
  48. #include "GramYacc.h"
  49. #endif
  50.  
  51. IO_tFile GramYacc_yyf;
  52. PROC GramYacc_Exit;
  53.  
  54. static Tree_tTree Node, ActClass, TheClass, TheAttr;
  55. static SHORTCARD ActActionIndex, PrevActionIndex;
  56. static BOOLEAN IsImplicit;
  57. static Tree_tTree GetBaseClass ARGS((Tree_tTree Class));
  58. static BOOLEAN IsLast ARGS((Tree_tTree Class, Tree_tTree Action));
  59. static void IsLast2 ARGS((Tree_tTree t, Tree_tTree Action, BOOLEAN *pFound, BOOLEAN *pLast));
  60. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  61. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  62. struct S_3 {
  63.     union {
  64.         char dummy;
  65.     } U_1;
  66. };
  67. static void ParsVariant ARGS((Tree_tTree t));
  68. struct S_4 {
  69.     union {
  70.         char dummy;
  71.     } U_1;
  72. };
  73. static void GenExt ARGS((Tree_tTree t));
  74. struct S_5 {
  75.     union {
  76.         char dummy;
  77.     } U_1;
  78. };
  79. static void Token ARGS((Tree_tTree t));
  80. struct S_6 {
  81.     union {
  82.         char dummy;
  83.     } U_1;
  84. };
  85. static void RecordField ARGS((Tree_tTree t));
  86. struct S_7 {
  87.     union {
  88.         char dummy;
  89.     } U_1;
  90. };
  91. static void PrecDefs ARGS((Tree_tTree t));
  92. struct S_8 {
  93.     union {
  94.         char dummy;
  95.     } U_1;
  96. };
  97. static void Grammar ARGS((Tree_tTree t));
  98. struct S_9 {
  99.     union {
  100.         char dummy;
  101.     } U_1;
  102. };
  103. static void Rule ARGS((Tree_tTree t));
  104. struct S_10 {
  105.     union {
  106.         char dummy;
  107.     } U_1;
  108. };
  109. static void Implicit ARGS((Tree_tTree t));
  110. struct S_11 {
  111.     union {
  112.         char dummy;
  113.     } U_1;
  114. };
  115. static void yyExit ARGS(());
  116.  
  117.  
  118. static Tree_tTree GetBaseClass
  119. # ifdef __STDC__
  120. (Tree_tTree Class)
  121. # else
  122. (Class)
  123. Tree_tTree Class;
  124. # endif
  125. {
  126.   while (Class->U_1.V_5.Class.BaseClass->U_1.V_1.Kind != Tree_NoClass) {
  127.     Class = Class->U_1.V_5.Class.BaseClass;
  128.   }
  129.   return Class;
  130. }
  131.  
  132. static BOOLEAN IsLast
  133. # ifdef __STDC__
  134. (Tree_tTree Class, Tree_tTree Action)
  135. # else
  136. (Class, Action)
  137. Tree_tTree Class, Action;
  138. # endif
  139. {
  140.   BOOLEAN Found, Last;
  141.  
  142.   IsLast2(Class, Action, &Found, &Last);
  143.   return Last;
  144. }
  145.  
  146. static void IsLast2
  147. # ifdef __STDC__
  148. (Tree_tTree t, Tree_tTree Action, BOOLEAN *pFound, BOOLEAN *pLast)
  149. # else
  150. (t, Action, pFound, pLast)
  151. Tree_tTree t, Action;
  152. BOOLEAN *pFound, *pLast;
  153. # endif
  154. {
  155.   BOOLEAN Found, Last;
  156.  
  157.   switch (t->U_1.V_1.Kind) {
  158.   case Tree_Class:;
  159.     IsLast2(t->U_1.V_5.Class.Attributes, Action, pFound, pLast);
  160.     if (*pFound || !*pLast) {
  161.       return;
  162.     }
  163.     IsLast2(t->U_1.V_5.Class.BaseClass, Action, pFound, pLast);
  164.     break;
  165.   case Tree_Child:;
  166.     IsLast2(t->U_1.V_9.Child.Next, Action, &Found, &Last);
  167.     *pFound = Found;
  168.     if (Found) {
  169.       *pLast = Last;
  170.     } else {
  171.       *pLast = FALSE;
  172.     }
  173.     break;
  174.   case Tree_Attribute:;
  175.     IsLast2(t->U_1.V_10.Attribute.Next, Action, pFound, pLast);
  176.     break;
  177.   case Tree_ActionPart:;
  178.     IsLast2(t->U_1.V_11.ActionPart.Next, Action, &Found, &Last);
  179.     *pFound = Found || Action == t;
  180.     if (Found) {
  181.       *pLast = Last;
  182.     } else {
  183.       *pLast = Last && Action == t;
  184.     }
  185.     break;
  186.   default :
  187.     *pFound = FALSE;
  188.     *pLast = TRUE;
  189.     break;
  190.   }
  191. }
  192.  
  193. static void yyAbort
  194. # ifdef __STDC__
  195. (CHAR yyFunction[], LONGCARD O_1)
  196. # else
  197. (yyFunction, O_1)
  198. CHAR yyFunction[];
  199. LONGCARD O_1;
  200. # endif
  201. {
  202.   OPEN_ARRAY_LOCALS
  203.  
  204.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  205.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  206.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module GramYacc, routine ", 32L);
  207.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  208.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  209.   IO_WriteNl((System_tFile)IO_StdError);
  210.   (*GramYacc_Exit)();
  211.   FREE_OPEN_ARRAYS
  212. }
  213.  
  214. static BOOLEAN yyIsEqual
  215. # ifdef __STDC__
  216. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  217. # else
  218. (yya, O_3, yyb, O_2)
  219. BYTE yya[];
  220. LONGCARD O_3;
  221. BYTE yyb[];
  222. LONGCARD O_2;
  223. # endif
  224. {
  225.   INTEGER yyi;
  226.   OPEN_ARRAY_LOCALS
  227.  
  228.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  229.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  230.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  231.   {
  232.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  233.  
  234.     if (B_1 <= B_2)
  235.       for (yyi = B_1;; yyi += 1) {
  236.         if (yya[yyi] != yyb[yyi]) {
  237.           FREE_OPEN_ARRAYS
  238.           return FALSE;
  239.         }
  240.         if (yyi >= B_2) break;
  241.       }
  242.   }
  243.   FREE_OPEN_ARRAYS
  244.   return TRUE;
  245. }
  246.  
  247. void GramYacc_ParsSpec
  248. # ifdef __STDC__
  249. (Tree_tTree t)
  250. # else
  251. (t)
  252. Tree_tTree t;
  253. # endif
  254. {
  255.   struct S_3 yyTempo;
  256.  
  257.   if (t == Tree_NoTree) {
  258.     return;
  259.   }
  260.   if (t->U_1.V_1.Kind == Tree_Ag) {
  261.     {
  262.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  263.  
  264.       IO_WriteS(Tree_f, (STRING)"%{", 2L);
  265.       IO_WriteNl(Tree_f);
  266.       IO_WriteS(Tree_f, (STRING)"# include \"Scanner.h\"", 21L);
  267.       IO_WriteNl(Tree_f);
  268.       IO_WriteS(Tree_f, (STRING)"/* EXPORT */", 12L);
  269.       IO_WriteNl(Tree_f);
  270.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Export);
  271.       Node = W_1->Modules;
  272.       while (Node->U_1.V_1.Kind == Tree_Module) {
  273.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Export);
  274.         Node = Node->U_1.V_43.Module.Next;
  275.       }
  276.       IO_WriteS(Tree_f, (STRING)"/* GLOBAL */", 12L);
  277.       IO_WriteNl(Tree_f);
  278.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Global);
  279.       Node = W_1->Modules;
  280.       while (Node->U_1.V_1.Kind == Tree_Module) {
  281.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Global);
  282.         Node = Node->U_1.V_43.Module.Next;
  283.       }
  284.       IO_WriteS(Tree_f, (STRING)"/* LOCAL */", 11L);
  285.       IO_WriteNl(Tree_f);
  286.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Local);
  287.       Node = W_1->Modules;
  288.       while (Node->U_1.V_1.Kind == Tree_Module) {
  289.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Local);
  290.         Node = Node->U_1.V_43.Module.Next;
  291.       }
  292.       IO_WriteNl(Tree_f);
  293.       IO_WriteS(Tree_f, (STRING)"void BeginParser ()", 19L);
  294.       IO_WriteNl(Tree_f);
  295.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  296.       IO_WriteNl(Tree_f);
  297.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Begin);
  298.       Node = W_1->Modules;
  299.       while (Node->U_1.V_1.Kind == Tree_Module) {
  300.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Begin);
  301.         Node = Node->U_1.V_43.Module.Next;
  302.       }
  303.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  304.       IO_WriteNl(Tree_f);
  305.       IO_WriteNl(Tree_f);
  306.       IO_WriteS(Tree_f, (STRING)"void CloseParser ()", 19L);
  307.       IO_WriteNl(Tree_f);
  308.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  309.       IO_WriteNl(Tree_f);
  310.       Texts_WriteText(Tree_f, W_1->ParserCodes->U_1.V_12.Codes.Close);
  311.       Node = W_1->Modules;
  312.       while (Node->U_1.V_1.Kind == Tree_Module) {
  313.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.ParserCodes->U_1.V_12.Codes.Close);
  314.         Node = Node->U_1.V_43.Module.Next;
  315.       }
  316.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  317.       IO_WriteNl(Tree_f);
  318.       IO_WriteNl(Tree_f);
  319.       ParsVariant(W_1->Classes);
  320.       IO_WriteS(Tree_f, (STRING)"%}", 2L);
  321.       IO_WriteNl(Tree_f);
  322.       IO_WriteNl(Tree_f);
  323.       IO_WriteS(Tree_f, (STRING)"%union {", 8L);
  324.       IO_WriteNl(Tree_f);
  325.       IO_WriteS(Tree_f, (STRING)" tScanAttribute Scan;", 21L);
  326.       IO_WriteNl(Tree_f);
  327.       Node = W_1->Classes;
  328.       while (Node->U_1.V_1.Kind == Tree_Class) {
  329.         {
  330.           register Tree_yClass *W_2 = &Node->U_1.V_5.Class;
  331.  
  332.           if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_2->Properties)) {
  333.             if (IN(Tree_String, W_2->Properties) && !IN(Tree_HasSelector, W_2->Properties)) {
  334.               IO_WriteS(Tree_f, (STRING)" yy", 3L);
  335.               Tree_WN((LONGINT)W_2->Name);
  336.               IO_WriteS(Tree_f, (STRING)" /* ", 4L);
  337.               Tree_WI(W_2->Name);
  338.               IO_WriteS(Tree_f, (STRING)" */ yy", 6L);
  339.               Tree_WN((LONGINT)W_2->Name);
  340.               IO_WriteS(Tree_f, (STRING)";", 1L);
  341.               IO_WriteNl(Tree_f);
  342.             } else {
  343.               IO_WriteS(Tree_f, (STRING)" yy", 3L);
  344.               Tree_WI(W_2->Selector);
  345.               IO_WriteS(Tree_f, (STRING)" ", 1L);
  346.               Tree_WI(W_2->Selector);
  347.               IO_WriteS(Tree_f, (STRING)";", 1L);
  348.               IO_WriteNl(Tree_f);
  349.             }
  350.           }
  351.           Node = W_2->Next;
  352.         }
  353.       }
  354.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  355.       IO_WriteNl(Tree_f);
  356.       IO_WriteNl(Tree_f);
  357.       IO_WriteS(Tree_f, (STRING)"%token", 6L);
  358.       IO_WriteNl(Tree_f);
  359.       Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)Token);
  360.       IO_WriteNl(Tree_f);
  361.       PrecDefs(W_1->Precs);
  362.       IO_WriteNl(Tree_f);
  363.       IO_WriteS(Tree_f, (STRING)"%%", 2L);
  364.       IO_WriteNl(Tree_f);
  365.       IO_WriteNl(Tree_f);
  366.       Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)GramYacc_ParsSpec);
  367.       return;
  368.     }
  369.   }
  370.   if (t->U_1.V_1.Kind == Tree_Class) {
  371.     {
  372.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  373.  
  374.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced), W_3->Properties)) {
  375.         TheClass = t;
  376.         Grammar(t);
  377.       }
  378.       return;
  379.     }
  380.   }
  381. }
  382.  
  383. static void ParsVariant
  384. # ifdef __STDC__
  385. (Tree_tTree t)
  386. # else
  387. (t)
  388. Tree_tTree t;
  389. # endif
  390. {
  391.   struct S_4 yyTempo;
  392.  
  393.   if (t == Tree_NoTree) {
  394.     return;
  395.   }
  396.   if (t->U_1.V_1.Kind == Tree_Class) {
  397.     {
  398.       register Tree_yClass *W_4 = &t->U_1.V_5.Class;
  399.  
  400.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Nonterminal) | SET_ELEM(Tree_Referenced) | SET_ELEM(Tree_HasAttributes), W_4->Properties)) {
  401.         IO_WriteS(Tree_f, (STRING)"typedef struct { ", 17L);
  402.         Tree_ForallAttributes(W_4->Attributes, (Tree_ProcOfT)RecordField);
  403.         GenExt(W_4->Extensions);
  404.         if (IN(Tree_String, W_4->Properties) && !IN(Tree_HasSelector, W_4->Properties)) {
  405.           IO_WriteS(Tree_f, (STRING)"} /* ", 5L);
  406.           Tree_WI(W_4->Name);
  407.           IO_WriteS(Tree_f, (STRING)" */ yy", 6L);
  408.           Tree_WN((LONGINT)W_4->Name);
  409.           IO_WriteS(Tree_f, (STRING)";", 1L);
  410.           IO_WriteNl(Tree_f);
  411.         } else {
  412.           IO_WriteS(Tree_f, (STRING)"} yy", 4L);
  413.           Tree_WI(W_4->Selector);
  414.           IO_WriteS(Tree_f, (STRING)";", 1L);
  415.           IO_WriteNl(Tree_f);
  416.         }
  417.       }
  418.       ParsVariant(W_4->Next);
  419.       return;
  420.     }
  421.   }
  422. }
  423.  
  424. static void GenExt
  425. # ifdef __STDC__
  426. (Tree_tTree t)
  427. # else
  428. (t)
  429. Tree_tTree t;
  430. # endif
  431. {
  432.   struct S_5 yyTempo;
  433.  
  434.   if (t == Tree_NoTree) {
  435.     return;
  436.   }
  437.   if (t->U_1.V_1.Kind == Tree_Class) {
  438.     {
  439.       register Tree_yClass *W_5 = &t->U_1.V_5.Class;
  440.  
  441.       Tree_ForallAttributes(W_5->Attributes, (Tree_ProcOfT)RecordField);
  442.       GenExt(W_5->Extensions);
  443.       GenExt(W_5->Next);
  444.       return;
  445.     }
  446.   }
  447. }
  448.  
  449. static void Token
  450. # ifdef __STDC__
  451. (Tree_tTree t)
  452. # else
  453. (t)
  454. Tree_tTree t;
  455. # endif
  456. {
  457.   struct S_6 yyTempo;
  458.  
  459.   if (t == Tree_NoTree) {
  460.     return;
  461.   }
  462.   if (t->U_1.V_1.Kind == Tree_Class) {
  463.     {
  464.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  465.  
  466.       if (SET_IS_SUBSET1(SET_ELEM(Tree_Terminal) | SET_ELEM(Tree_Referenced), W_6->Properties)) {
  467.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  468.         Tree_WI(W_6->Name);
  469.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  470.         Tree_WN((LONGINT)W_6->Code);
  471.         IO_WriteNl(Tree_f);
  472.       }
  473.       return;
  474.     }
  475.   }
  476. }
  477.  
  478. static void RecordField
  479. # ifdef __STDC__
  480. (Tree_tTree t)
  481. # else
  482. (t)
  483. Tree_tTree t;
  484. # endif
  485. {
  486.   struct S_7 yyTempo;
  487.  
  488.   if (t == Tree_NoTree) {
  489.     return;
  490.   }
  491.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  492.     {
  493.       register Tree_yAttribute *W_7 = &t->U_1.V_10.Attribute;
  494.  
  495.       if ((Tree_NoCodeAttr & W_7->Properties) == 0X0L) {
  496.         Tree_WI(W_7->Type);
  497.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  498.         Tree_WI(W_7->Name);
  499.         IO_WriteS(Tree_f, (STRING)"; ", 2L);
  500.       }
  501.       return;
  502.     }
  503.   }
  504. }
  505.  
  506. static void PrecDefs
  507. # ifdef __STDC__
  508. (Tree_tTree t)
  509. # else
  510. (t)
  511. Tree_tTree t;
  512. # endif
  513. {
  514.   struct S_8 yyTempo;
  515.  
  516.   if (t == Tree_NoTree) {
  517.     return;
  518.   }
  519.   if (t->U_1.V_1.Kind == Tree_LeftAssoc) {
  520.     {
  521.       register Tree_yLeftAssoc *W_8 = &t->U_1.V_30.LeftAssoc;
  522.  
  523.       IO_WriteS(Tree_f, (STRING)"%left ", 6L);
  524.       PrecDefs(W_8->Names);
  525.       IO_WriteNl(Tree_f);
  526.       PrecDefs(W_8->Next);
  527.       return;
  528.     }
  529.   }
  530.   if (t->U_1.V_1.Kind == Tree_RightAssoc) {
  531.     {
  532.       register Tree_yRightAssoc *W_9 = &t->U_1.V_31.RightAssoc;
  533.  
  534.       IO_WriteS(Tree_f, (STRING)"%right", 6L);
  535.       PrecDefs(W_9->Names);
  536.       IO_WriteNl(Tree_f);
  537.       PrecDefs(W_9->Next);
  538.       return;
  539.     }
  540.   }
  541.   if (t->U_1.V_1.Kind == Tree_NonAssoc) {
  542.     {
  543.       register Tree_yNonAssoc *W_10 = &t->U_1.V_32.NonAssoc;
  544.  
  545.       IO_WriteS(Tree_f, (STRING)"%none ", 6L);
  546.       PrecDefs(W_10->Names);
  547.       IO_WriteNl(Tree_f);
  548.       PrecDefs(W_10->Next);
  549.       return;
  550.     }
  551.   }
  552.   if (t->U_1.V_1.Kind == Tree_Name) {
  553.     {
  554.       register Tree_yName *W_11 = &t->U_1.V_25.Name;
  555.  
  556.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  557.       Tree_WI(W_11->Name);
  558.       PrecDefs(W_11->Next);
  559.       return;
  560.     }
  561.   }
  562. }
  563.  
  564. static void Grammar
  565. # ifdef __STDC__
  566. (Tree_tTree t)
  567. # else
  568. (t)
  569. Tree_tTree t;
  570. # endif
  571. {
  572.   struct S_9 yyTempo;
  573.  
  574.   if (t == Tree_NoTree) {
  575.     return;
  576.   }
  577.   if (t->U_1.V_1.Kind == Tree_Class) {
  578.     {
  579.       register Tree_yClass *W_12 = &t->U_1.V_5.Class;
  580.  
  581.       if (W_12->Extensions->U_1.V_1.Kind == Tree_NoClass) {
  582.         {
  583.           register Tree_yClass *W_13 = &TheClass->U_1.V_5.Class;
  584.  
  585.           if (IN(Tree_String, W_13->Properties)) {
  586.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  587.             Tree_WN((LONGINT)W_13->Name);
  588.           } else {
  589.             Tree_WI(W_13->Name);
  590.           }
  591.         }
  592.         IO_WriteS(Tree_f, (STRING)"    : ", 3L);
  593.         ActClass = t;
  594.         PrevActionIndex = 0;
  595.         IsImplicit = FALSE;
  596.         Tree_ForallAttributes(t, (Tree_ProcOfT)Rule);
  597.         if (W_12->Prec != Idents_NoIdent) {
  598.           IO_WriteS(Tree_f, (STRING)"%prec ", 6L);
  599.           Tree_WI(W_12->Prec);
  600.           IO_WriteS(Tree_f, (STRING)" ", 1L);
  601.         }
  602.         IO_WriteS(Tree_f, (STRING)";", 1L);
  603.         IO_WriteNl(Tree_f);
  604.         PrevActionIndex = 0;
  605.         IsImplicit = TRUE;
  606.         Tree_ForallAttributes(t, (Tree_ProcOfT)Implicit);
  607.       } else {
  608.         Rule(W_12->Extensions);
  609.       }
  610.       return;
  611.     }
  612.   }
  613. }
  614.  
  615. static void Rule
  616. # ifdef __STDC__
  617. (Tree_tTree t)
  618. # else
  619. (t)
  620. Tree_tTree t;
  621. # endif
  622. {
  623.   struct S_10 yyTempo;
  624.  
  625.   if (t == Tree_NoTree) {
  626.     return;
  627.   }
  628.   switch (t->U_1.V_1.Kind) {
  629.   case Tree_Class:;
  630.     {
  631.       register Tree_yClass *W_14 = &t->U_1.V_5.Class;
  632.  
  633.       Grammar(t);
  634.       Rule(W_14->Next);
  635.       return;
  636.     }
  637.     break;
  638.   case Tree_Child:;
  639.     {
  640.       register Tree_yChild *W_15 = &t->U_1.V_9.Child;
  641.  
  642.       if (SET_IS_SUBSET1(SET_ELEM(Tree_String) | SET_ELEM(Tree_Nonterminal), W_15->Class->U_1.V_5.Class.Properties)) {
  643.         IO_WriteS(Tree_f, (STRING)"yy", 2L);
  644.         Tree_WN((LONGINT)W_15->Type);
  645.       } else {
  646.         Tree_WI(W_15->Type);
  647.       }
  648.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  649.       return;
  650.     }
  651.     break;
  652.   case Tree_ActionPart:;
  653.     {
  654.       register Tree_yActionPart *W_16 = &t->U_1.V_11.ActionPart;
  655.  
  656.       if (!Sets_IsElement(ORD('v'), &Tree_Options)) {
  657.         if (IsLast(ActClass, t)) {
  658.           IO_WriteS(Tree_f, (STRING)"{", 1L);
  659.           if (PrevActionIndex != 0) {
  660.             Node = GetBaseClass(TheClass);
  661.             {
  662.               register Tree_yClass *W_17 = &Node->U_1.V_5.Class;
  663.  
  664.               IO_WriteS(Tree_f, (STRING)" $$.", 4L);
  665.               if (IN(Tree_String, W_17->Properties)) {
  666.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  667.                 Tree_WN((LONGINT)W_17->Name);
  668.               } else {
  669.                 Tree_WI(W_17->Name);
  670.               }
  671.               IO_WriteS(Tree_f, (STRING)" = $", 4L);
  672.               Tree_WN((LONGINT)PrevActionIndex);
  673.               IO_WriteS(Tree_f, (STRING)".", 1L);
  674.               if (IN(Tree_String, W_17->Properties)) {
  675.                 IO_WriteS(Tree_f, (STRING)"yy", 2L);
  676.                 Tree_WN((LONGINT)W_17->Name);
  677.               } else {
  678.                 Tree_WI(W_17->Name);
  679.               }
  680.               IO_WriteS(Tree_f, (STRING)";", 1L);
  681.               IO_WriteNl(Tree_f);
  682.             }
  683.           }
  684.           Rule(W_16->Actions);
  685.           IO_WriteS(Tree_f, (STRING)"} ", 2L);
  686.         } else {
  687.           IO_WriteS(Tree_f, (STRING)"xx", 2L);
  688.           Tree_WN((LONGINT)W_16->Name);
  689.           IO_WriteS(Tree_f, (STRING)" ", 1L);
  690.         }
  691.         PrevActionIndex = W_16->ParsIndex;
  692.       }
  693.       return;
  694.     }
  695.     break;
  696.   case Tree_Assign:;
  697.     {
  698.       register Tree_yAssign *W_18 = &t->U_1.V_36.Assign;
  699.  
  700.       Rule(W_18->Results);
  701.       IO_WriteS(Tree_f, (STRING)"=", 1L);
  702.       Rule(W_18->Arguments);
  703.       IO_WriteS(Tree_f, (STRING)";", 1L);
  704.       IO_WriteNl(Tree_f);
  705.       Rule(W_18->Next);
  706.       return;
  707.     }
  708.     break;
  709.   case Tree_Copy:;
  710.     {
  711.       register Tree_yCopy *W_19 = &t->U_1.V_37.Copy;
  712.  
  713.       Rule(W_19->Results);
  714.       IO_WriteS(Tree_f, (STRING)" = ", 3L);
  715.       Rule(W_19->Arguments);
  716.       IO_WriteS(Tree_f, (STRING)";", 1L);
  717.       IO_WriteNl(Tree_f);
  718.       Rule(W_19->Next);
  719.       return;
  720.     }
  721.     break;
  722.   case Tree_TargetCode:;
  723.     {
  724.       register Tree_yTargetCode *W_20 = &t->U_1.V_38.TargetCode;
  725.  
  726.       Rule(W_20->Code);
  727.       IO_WriteS(Tree_f, (STRING)";", 1L);
  728.       IO_WriteNl(Tree_f);
  729.       Rule(W_20->Next);
  730.       return;
  731.     }
  732.     break;
  733.   case Tree_Order:;
  734.     {
  735.       register Tree_yOrder *W_21 = &t->U_1.V_39.Order;
  736.  
  737.       Rule(W_21->Next);
  738.       return;
  739.     }
  740.     break;
  741.   case Tree_Check:;
  742.     {
  743.       register Tree_yCheck *W_22 = &t->U_1.V_40.Check;
  744.  
  745.       if (W_22->Statement != Tree_NoTree) {
  746.         if (W_22->Condition != Tree_NoTree) {
  747.           IO_WriteS(Tree_f, (STRING)"if (", 4L);
  748.           Rule(W_22->Condition);
  749.           IO_WriteS(Tree_f, (STRING)") ; else { ", 11L);
  750.           Rule(W_22->Statement);
  751.           IO_WriteS(Tree_f, (STRING)" }", 2L);
  752.           IO_WriteNl(Tree_f);
  753.         } else {
  754.           Rule(W_22->Statement);
  755.         }
  756.       }
  757.       Rule(W_22->Next);
  758.       return;
  759.     }
  760.     break;
  761.   case Tree_Designator:;
  762.     {
  763.       register Tree_yDesignator *W_23 = &t->U_1.V_15.Designator;
  764.  
  765.       TheAttr = Tree_IdentifyAttribute(ActClass, W_23->Selector);
  766.       if (TheAttr != Tree_NoTree) {
  767.         Node = TheAttr->U_1.V_9.Child.Class;
  768.         if (Node != Tree_NoTree) {
  769.           IO_WriteS(Tree_f, (STRING)"$", 1L);
  770.           if (!IsImplicit) {
  771.             Tree_WN((LONGINT)TheAttr->U_1.V_9.Child.ParsIndex);
  772.           } else {
  773.             Tree_WN((LONGINT)(SHORTINT)(TheAttr->U_1.V_9.Child.ParsIndex + 1 - ActActionIndex));
  774.           }
  775.           if (IN(Tree_Nonterminal, Node->U_1.V_5.Class.Properties)) {
  776.             Node = GetBaseClass(Node);
  777.             if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  778.               IO_WriteS(Tree_f, (STRING)".yy", 3L);
  779.               Tree_WN((LONGINT)Node->U_1.V_5.Class.Name);
  780.             } else {
  781.               IO_WriteS(Tree_f, (STRING)".", 1L);
  782.               Tree_WI(Node->U_1.V_5.Class.Name);
  783.             }
  784.           } else {
  785.             if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  786.               IO_WriteS(Tree_f, (STRING)".Scan.yy", 8L);
  787.               Tree_WN((LONGINT)Node->U_1.V_5.Class.Code);
  788.             } else {
  789.               IO_WriteS(Tree_f, (STRING)".Scan.", 6L);
  790.               Tree_WI(Node->U_1.V_5.Class.Selector);
  791.             }
  792.           }
  793.           IO_WriteS(Tree_f, (STRING)".", 1L);
  794.           Tree_WI(W_23->Attribute);
  795.         } else {
  796.           Tree_WI(W_23->Selector);
  797.           IO_WriteS(Tree_f, (STRING)":", 1L);
  798.           Tree_WI(W_23->Attribute);
  799.         }
  800.       } else {
  801.         Tree_WI(W_23->Selector);
  802.         IO_WriteS(Tree_f, (STRING)":", 1L);
  803.         Tree_WI(W_23->Attribute);
  804.       }
  805.       Rule(W_23->Next);
  806.       return;
  807.     }
  808.     break;
  809.   case Tree_Ident:;
  810.     {
  811.       register Tree_yIdent *W_24 = &t->U_1.V_16.Ident;
  812.  
  813.       TheAttr = Tree_IdentifyAttribute(ActClass, W_24->Attribute);
  814.       Node = GetBaseClass(TheClass);
  815.       if (TheAttr != Tree_NoTree) {
  816.         if (IN(Tree_String, Node->U_1.V_5.Class.Properties) && !IN(Tree_HasSelector, Node->U_1.V_5.Class.Properties)) {
  817.           IO_WriteS(Tree_f, (STRING)"$$.yy", 5L);
  818.           Tree_WN((LONGINT)Node->U_1.V_5.Class.Name);
  819.           IO_WriteS(Tree_f, (STRING)".", 1L);
  820.           Tree_WI(W_24->Attribute);
  821.         } else {
  822.           IO_WriteS(Tree_f, (STRING)"$$.", 3L);
  823.           Tree_WI(Node->U_1.V_5.Class.Name);
  824.           IO_WriteS(Tree_f, (STRING)".", 1L);
  825.           Tree_WI(W_24->Attribute);
  826.         }
  827.       } else {
  828.         Tree_WI(W_24->Attribute);
  829.       }
  830.       Rule(W_24->Next);
  831.       return;
  832.     }
  833.     break;
  834.   case Tree_Any:;
  835.     {
  836.       register Tree_yAny *W_25 = &t->U_1.V_18.Any;
  837.  
  838.       StringMem_WriteString(Tree_f, W_25->Code);
  839.       Rule(W_25->Next);
  840.       return;
  841.     }
  842.     break;
  843.   case Tree_Anys:;
  844.     {
  845.       register Tree_yAnys *W_26 = &t->U_1.V_19.Anys;
  846.  
  847.       Rule(W_26->Layouts);
  848.       Rule(W_26->Next);
  849.       return;
  850.     }
  851.     break;
  852.   case Tree_LayoutAny:;
  853.     {
  854.       register Tree_yLayoutAny *W_27 = &t->U_1.V_22.LayoutAny;
  855.  
  856.       StringMem_WriteString(Tree_f, W_27->Code);
  857.       Rule(W_27->Next);
  858.       return;
  859.     }
  860.     break;
  861.   default :
  862.     break;
  863.   }
  864. }
  865.  
  866. static void Implicit
  867. # ifdef __STDC__
  868. (Tree_tTree t)
  869. # else
  870. (t)
  871. Tree_tTree t;
  872. # endif
  873. {
  874.   struct S_11 yyTempo;
  875.  
  876.   if (t == Tree_NoTree) {
  877.     return;
  878.   }
  879.   if (t->U_1.V_1.Kind == Tree_ActionPart) {
  880.     {
  881.       register Tree_yActionPart *W_28 = &t->U_1.V_11.ActionPart;
  882.  
  883.       if (!IN(Tree_Generated, W_28->Properties) && !IsLast(ActClass, t)) {
  884.         INCL(W_28->Properties, Tree_Generated);
  885.         ActActionIndex = W_28->ParsIndex;
  886.         IO_WriteS(Tree_f, (STRING)"xx", 2L);
  887.         Tree_WN((LONGINT)W_28->Name);
  888.         IO_WriteS(Tree_f, (STRING)"    : {", 4L);
  889.         if (PrevActionIndex != 0) {
  890.           Node = GetBaseClass(TheClass);
  891.           {
  892.             register Tree_yClass *W_29 = &Node->U_1.V_5.Class;
  893.  
  894.             IO_WriteS(Tree_f, (STRING)" $$.", 4L);
  895.             if (IN(Tree_String, W_29->Properties)) {
  896.               IO_WriteS(Tree_f, (STRING)"yy", 2L);
  897.               Tree_WN((LONGINT)W_29->Name);
  898.             } else {
  899.               Tree_WI(W_29->Name);
  900.             }
  901.             IO_WriteS(Tree_f, (STRING)" = $", 4L);
  902.             Tree_WN((LONGINT)(SHORTINT)(PrevActionIndex + 1 - ActActionIndex));
  903.             IO_WriteS(Tree_f, (STRING)".", 1L);
  904.             if (IN(Tree_String, W_29->Properties)) {
  905.               IO_WriteS(Tree_f, (STRING)"yy", 2L);
  906.               Tree_WN((LONGINT)W_29->Name);
  907.             } else {
  908.               Tree_WI(W_29->Name);
  909.             }
  910.             IO_WriteS(Tree_f, (STRING)";", 1L);
  911.             IO_WriteNl(Tree_f);
  912.           }
  913.         }
  914.         Rule(W_28->Actions);
  915.         IO_WriteS(Tree_f, (STRING)"} .", 3L);
  916.         IO_WriteNl(Tree_f);
  917.       }
  918.       PrevActionIndex = W_28->ParsIndex;
  919.       return;
  920.     }
  921.   }
  922. }
  923.  
  924. void GramYacc_BeginGramYacc
  925. # ifdef __STDC__
  926. ()
  927. # else
  928. ()
  929. # endif
  930. {
  931. }
  932.  
  933. void GramYacc_CloseGramYacc
  934. # ifdef __STDC__
  935. ()
  936. # else
  937. ()
  938. # endif
  939. {
  940. }
  941.  
  942. static void yyExit
  943. # ifdef __STDC__
  944. ()
  945. # else
  946. ()
  947. # endif
  948. {
  949.   IO_CloseIO();
  950.   Exit(1L);
  951. }
  952.  
  953. void BEGIN_GramYacc()
  954. {
  955.   static BOOLEAN has_been_called = FALSE;
  956.  
  957.   if (!has_been_called) {
  958.     has_been_called = TRUE;
  959.  
  960.     BEGIN_IO();
  961.     BEGIN_Tree();
  962.     BEGIN_System();
  963.     BEGIN_IO();
  964.     BEGIN_Tree();
  965.     BEGIN_IO();
  966.     BEGIN_StringMem();
  967.     BEGIN_Idents();
  968.     BEGIN_Texts();
  969.     BEGIN_Sets();
  970.     BEGIN_TreeC2();
  971.     BEGIN_Tree();
  972.     BEGIN_Strings();
  973.  
  974.     GramYacc_yyf = IO_StdOutput;
  975.     GramYacc_Exit = yyExit;
  976.     GramYacc_BeginGramYacc();
  977.   }
  978. }
  979.